package com.hh.erp.util;

import com.hh.erp.util.http.Constants;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.ss.usermodel.IndexedColors;
import org.hamcrest.core.Is;

import java.util.UUID;

public class StringUtil {

    public static boolean IsSpace(Object str) {
        if (str == null)
            return true;
        else if (str == "")
            return true;
        else if (str.equals(""))
            return true;
        else
            return false;
    }

    public static boolean Equals(Object params1, Object params2) {
        if (params1 == null && params2 != null) {
            return false;
        }
        if (params1 != null && params2 == null) {
            return false;
        }
        if (params1 == null && params2 == null) {
            return true;
        }
        if (params1.toString().contentEquals(params2.toString())) {
            return true;
        } else {
            return false;
        }
    }

    public static String deleteUTF8Bom(String fileStr) {
        byte[] UTF8_BOM_BYTES = new byte[]{(byte) 0xEF, (byte) 0xBB, (byte) 0xBF};
        byte[] bytes = fileStr.getBytes();
        if (bytes[0] == UTF8_BOM_BYTES[0]
                && bytes[1] == UTF8_BOM_BYTES[1]
                && bytes[2] == UTF8_BOM_BYTES[2]) {
            return new String(bytes, 3, bytes.length - 3);
        }
        return fileStr;
    }

    public static void main(String[] args) {
        System.out.println(getId());
    }

    /**
     * 生成token
     *
     * @return
     */
    public static String getToken() {
        return UUID.randomUUID().toString().replace("-", "");
    }

    public static String getId() {
        StringBuilder sb = new StringBuilder();
        // 2.循环产生随机字符
        for (int i = 0; i < 15; i++) {
            //需要解决当前产生的字符应该是数字大写字母还是小写字母
            int num = (int) (Math.random() * 10000);
            int result = num % 3;//0 or 1 or 2
            int chInt;
            char ch;
            switch (result) {
                case 0://产生一个大写字符
                    chInt = (int) (Math.random() * (91 - 65) + 65);
                    ch = (char) chInt;
                    // 6.将产生的字符添加到StringBuiler中
                    sb.append(ch);
                    break;
                case 1://产生一个数字
                    // 4.中间5个字符,随机对应的数字[0,10)
                    chInt = (int) (Math.random() * 10);
                    // 6.将产生的数字添加到StringBuiler中
                    sb.append(chInt);
                    break;
                case 2://产生一个小写字符
                    // 5.后面5个字符随机产生小写字符,小写字母对应的数字[97,123)
                    chInt = (int) (Math.random() * (123 - 97) + 97);
                    ch = (char) chInt;
                    // 6.将产生的字符添加到StringBuiler中
                    sb.append(ch);
                    break;
                default:
                    break;
            }
        }
        return sb.toString();
    }

    /**
     * 首字母大写
     *
     * @param path
     * @return
     */
    public static String capitalize(String path) {
        return StringUtils.capitalize(path);
    }

    /**
     * 是否为http(s)://开头
     *
     * @param link 链接
     * @return 结果
     */
    public static boolean ishttp(String link) {
        return StringUtils.startsWithAny(link, Constants.HTTP, Constants.HTTPS);
    }

    /**
     * 是否为 当前项目包 (com.hh.erp) 开头
     *
     * @return
     */
    public static boolean isLocalHH(String link) {
        return StringUtils.startsWithAny(link, Constants.PACKAGE);
    }

    public static String replaceEach(String text, String[] searchList, String[] replacementList) {
        return StringUtils.replaceEach(text, searchList, replacementList);
    }

    public static String join(Object[] array, String delimiter) {
        return StringUtils.join(array, delimiter);
    }

    /**
     * 验证 str 是否在 strs 中
     *
     * @param str  验证字符串
     * @param strs 字符串组
     * @return 包含返回true
     */
    public static boolean inStringIgnoreCase(String str, String... strs) {
        if (str != null && strs != null) {
            for (String s : strs) {
                if (str.equalsIgnoreCase(trim(s))) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 去空格
     */
    public static String trim(String str) {
        return (str == null ? "" : str.trim());
    }

    public static Integer length(CharSequence cs) {
        return StringUtils.length(cs);
    }

    public static String[] split(String str, String separatorChars) {
        return StringUtils.split(str, separatorChars);
    }

    public static int indexOfIgnoreCase(CharSequence str, CharSequence searchStr) {
        return StringUtils.indexOfIgnoreCase(str, searchStr);
    }

    public static Boolean contains(String str, String s) {
        String str1 = str == null ? "" : str;
        String str2 = s == null ? "" : s;
        return str1.toUpperCase().contains(str2.toUpperCase());
    }

    /**
     * 格式化字符串<br>
     * 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
     * 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>
     * 例：<br>
     * 通常使用：format("this is {} for {}", "a", "b") -> this is a for b<br>
     * 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>
     * 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
     *
     * @param strPattern 字符串模板
     * @param argArray 参数列表
     * @return 结果
     */
    public static final String EMPTY_JSON = "{}";
    public static final char C_BACKSLASH = '\\';
    public static final char C_DELIM_START = '{';
    public static final char C_DELIM_END = '}';
    public static String format(final String strPattern, final Object... argArray)
    {
        if (StringUtil.IsSpace(strPattern) || StringUtil.IsSpace(argArray))
        {
            return strPattern;
        }
        final int strPatternLength = strPattern.length();

        // 初始化定义好的长度以获得更好的性能
        StringBuilder sbuf = new StringBuilder(strPatternLength + 50);

        int handledPosition = 0;
        int delimIndex;// 占位符所在位置
        for (int argIndex = 0; argIndex < argArray.length; argIndex++)
        {
            delimIndex = strPattern.indexOf(EMPTY_JSON, handledPosition);
            if (delimIndex == -1)
            {
                if (handledPosition == 0)
                {
                    return strPattern;
                }
                else
                { // 字符串模板剩余部分不再包含占位符，加入剩余部分后返回结果
                    sbuf.append(strPattern, handledPosition, strPatternLength);
                    return sbuf.toString();
                }
            }
            else
            {
                if (delimIndex > 0 && strPattern.charAt(delimIndex - 1) == C_BACKSLASH)
                {
                    if (delimIndex > 1 && strPattern.charAt(delimIndex - 2) == C_BACKSLASH)
                    {
                        // 转义符之前还有一个转义符，占位符依旧有效
                        sbuf.append(strPattern, handledPosition, delimIndex - 1);
                        sbuf.append(Convert.utf8Str(argArray[argIndex]));
                        handledPosition = delimIndex + 2;
                    }
                    else
                    {
                        // 占位符被转义
                        argIndex--;
                        sbuf.append(strPattern, handledPosition, delimIndex - 1);
                        sbuf.append(C_DELIM_START);
                        handledPosition = delimIndex + 1;
                    }
                }
                else
                {
                    // 正常占位符
                    sbuf.append(strPattern, handledPosition, delimIndex);
                    sbuf.append(Convert.utf8Str(argArray[argIndex]));
                    handledPosition = delimIndex + 2;
                }
            }
        }
        // 加入最后一个占位符后所有的字符
        sbuf.append(strPattern, handledPosition, strPattern.length());

        return sbuf.toString();
    }

    /**
     * 数字左边补齐0，使之达到指定长度。注意，如果数字转换为字符串后，长度大于size，则只保留 最后size个字符。
     *
     * @param num 数字对象
     * @param size 字符串指定长度
     * @return 返回数字的字符串格式，该字符串为指定长度。
     */
    public static final String padl(final Number num, final int size)
    {
        return padl(num.toString(), size, '0');
    }

    /**
     * 字符串左补齐。如果原始字符串s长度大于size，则只保留最后size个字符。
     *
     * @param s 原始字符串
     * @param size 字符串指定长度
     * @param c 用于补齐的字符
     * @return 返回指定长度的字符串，由原字符串左补齐或截取得到。
     */
    public static final String padl(final String s, final int size, final char c)
    {
        final StringBuilder sb = new StringBuilder(size);
        if (s != null)
        {
            final int len = s.length();
            if (s.length() <= size)
            {
                for (int i = size - len; i > 0; i--)
                {
                    sb.append(c);
                }
                sb.append(s);
            }
            else
            {
                return s.substring(len - size, len);
            }
        }
        else
        {
            for (int i = size; i > 0; i--)
            {
                sb.append(c);
            }
        }
        return sb.toString();
    }
}
